home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / lalr.lha / lalr / lib / Parser.mi < prev    next >
Text File  |  1992-08-18  |  16KB  |  471 lines
  1. (* $Id: Parser.mi,v 2.8 1992/08/12 06:54:05 grosch rel $ *)
  2.  
  3. $@ IMPLEMENTATION MODULE @;
  4.  
  5. $@ IMPORT SYSTEM, $, Positions, Errors, Strings, DynArray, Sets, System;
  6.  
  7. $G    (* GLOBAL section is inserted here *)
  8.  
  9. CONST
  10.    yyInitStackSize    = 100;
  11.    yyNoState        = 0;
  12.  
  13. $T    (* Table Constants are inserted here *)
  14.  
  15.    yyFirstFinalState    = yyFirstReadTermState;
  16.    yyLastState        = yyLastReduceState;
  17.  
  18. TYPE
  19.    yyTableElmt        = SHORTCARD;
  20.    yyTCombRange        = yyTableElmt [0 .. yyTableMax];
  21.    yyNCombRange        = yyTableElmt [yyLastTerminal + 1 .. yyNTableMax];
  22.    yyStateRange        = yyTableElmt [0 .. yyLastState];
  23.    yyReadRange        = yyTableElmt [yyFirstReadState .. yyLastReadState];
  24.    yyReadReduceRange    = yyTableElmt [yyFirstReadTermState ..yyLastReadNontermState];
  25.    yyReduceRange    = yyTableElmt [yyFirstReduceState .. yyLastReduceState];
  26.    yySymbolRange    = yyTableElmt [yyFirstSymbol .. yyLastSymbol];
  27.    yyTCombType        = RECORD Check, Next: yyStateRange; END;
  28.    yyNCombType        = yyStateRange;
  29.    yyTCombTypePtr    = POINTER TO yyTCombType;
  30.    yyNCombTypePtr    = POINTER TO yyNCombType;
  31.    yyStackType        = POINTER TO ARRAY [0 .. 1000000] OF yyStateRange;
  32.  
  33. VAR
  34.    yyTBasePtr        : ARRAY [0 .. yyLastReadState]    OF yyTCombTypePtr;
  35.    yyNBasePtr        : ARRAY [0 .. yyLastReadState]    OF yyNCombTypePtr;
  36.    yyDefault        : ARRAY [0 .. yyLastReadState]    OF yyReadRange    ;
  37.    yyTComb        : ARRAY yyTCombRange        OF yyTCombType    ;
  38.    yyNComb        : ARRAY yyNCombRange        OF yyNCombType    ;
  39.    yyLength        : ARRAY yyReduceRange        OF yyTableElmt    ;
  40.    yyLeftHandSide    : ARRAY yyReduceRange        OF yySymbolRange;
  41.    yyContinuation    : ARRAY [0 .. yyLastReadState]    OF yySymbolRange;
  42.    yyFinalToProd    : ARRAY yyReadReduceRange    OF yyReduceRange;
  43.    yyIsInitialized    : BOOLEAN;
  44.    yyTableFile        : System.tFile;
  45.  
  46. PROCEDURE TokenName (Token: CARDINAL; VAR Name: ARRAY OF CHAR);
  47.    PROCEDURE Copy (Source: ARRAY OF CHAR; VAR Target: ARRAY OF CHAR);
  48.       VAR i, j: CARDINAL;
  49.       BEGIN
  50.      IF HIGH (Source) < HIGH (Target)
  51.      THEN j := HIGH (Source); ELSE j := HIGH (Target); END;
  52.      FOR i := 0 TO j DO Target [i] := Source [i]; END;
  53.      IF HIGH (Target) > j THEN Target [j + 1] := CHR (0); END;
  54.       END Copy;
  55.    BEGIN
  56.       CASE Token OF
  57. $W    (* token names are inserted here *)
  58.       END;
  59.    END TokenName;
  60.  
  61. $@ PROCEDURE @ (): CARDINAL;
  62. $L    (* LOCAL section is inserted here *)
  63.    VAR
  64.       yyState        : yyStateRange;
  65.       yyTerminal    : yySymbolRange;
  66.       yyNonterminal    : yySymbolRange;    (* left-hand side symbol *)
  67.       yyStackPtr    : yyTableElmt;
  68.       yyStateStackSize    : LONGINT;
  69.       yyAttrStackSize    : LONGINT;
  70.       yyShortStackSize    : yyTableElmt;
  71.       yyStateStack    : yyStackType;
  72.       yyAttributeStack    : POINTER TO ARRAY [0 .. 1000000] OF tParsAttribute;
  73.       yySynAttribute    : tParsAttribute;    (* synthesized attribute *)
  74. $@       yyRepairAttribute : $.tScanAttribute;
  75.       yyRepairToken    : yySymbolRange;
  76.       yyTCombPtr    : yyTCombTypePtr;
  77.       yyNCombPtr    : yyNCombTypePtr;
  78.       yyIsRepairing    : BOOLEAN;
  79.       yyErrorCount    : CARDINAL;
  80.       yyTokenString    : ARRAY [0..127] OF CHAR;
  81.    BEGIN
  82. $@       Begin@;
  83.       yyState        := yyStartState;
  84. $@       yyTerminal    := $.GetToken ();
  85.       yyStateStackSize    := yyInitStackSize;
  86.       yyAttrStackSize    := yyInitStackSize;
  87.       DynArray.MakeArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  88.       DynArray.MakeArray (yyAttributeStack, yyAttrStackSize, SYSTEM.TSIZE (tParsAttribute));
  89.       yyShortStackSize    := yyStateStackSize - 1;
  90.       yyStackPtr    := 0;
  91.       yyErrorCount    := 0;
  92.       yyIsRepairing    := FALSE;
  93.  
  94.       LOOP
  95.      IF yyStackPtr >= yyShortStackSize THEN
  96.         DynArray.ExtendArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  97.         DynArray.ExtendArray (yyAttributeStack, yyAttrStackSize, SYSTEM.TSIZE (tParsAttribute));
  98.         yyShortStackSize := yyStateStackSize - 1;
  99.      END;
  100.      yyStateStack^ [yyStackPtr] := yyState;
  101.  
  102.      LOOP    (* SPEC State := Next (State, Terminal); terminal transition *)
  103.         yyTCombPtr := yyTCombTypePtr (LONGCARD (yyTBasePtr [yyState]) 
  104.                  + yyTerminal * SYSTEM.TSIZE (yyTCombType));
  105.         IF yyTCombPtr^.Check = yyState THEN
  106.            yyState := yyTCombPtr^.Next;
  107.            EXIT;
  108.         END;
  109.         yyState := yyDefault [yyState];
  110.  
  111.         IF yyState = yyNoState THEN            (* syntax error *)
  112.            yyState := yyStateStack^ [yyStackPtr];
  113.            IF yyIsRepairing THEN            (* repair *)
  114.           yyRepairToken := yyContinuation [yyState];
  115.           yyState := Next (yyState, yyRepairToken);
  116.           IF yyState <= yyLastReadTermState THEN (* read or read terminal reduce ? *)
  117. $@              $.ErrorAttribute (yyRepairToken, yyRepairAttribute);
  118.              TokenName (yyRepairToken, yyTokenString);
  119.              Errors.ErrorMessageI (Errors.TokenInserted, Errors.Repair,
  120. $@             $.Attribute.Position, Errors.Array, SYSTEM.ADR (yyTokenString));
  121.              IF yyState >= yyFirstFinalState THEN (* avoid second push *)
  122.             yyState := yyFinalToProd [yyState];
  123.              END;
  124.              INC (yyStackPtr);
  125.              yyAttributeStack^ [yyStackPtr].Scan := yyRepairAttribute;
  126.              yyStateStack^     [yyStackPtr] := yyState;
  127.           END;
  128.           IF yyState >= yyFirstFinalState THEN    (* final state ? *)
  129.             EXIT;
  130.           END;
  131.            ELSE                    (* report and recover *)
  132.           INC (yyErrorCount);
  133.           ErrorRecovery (yyTerminal, yyStateStack, yyStateStackSize, yyStackPtr);
  134.           yyIsRepairing := TRUE;
  135.            END;
  136.         END;
  137.      END;
  138.  
  139.      IF yyState >= yyFirstFinalState THEN        (* final state ? *)
  140.         IF yyState <= yyLastReadTermState THEN    (* read terminal reduce ? *)
  141.            INC (yyStackPtr);
  142. $@            yyAttributeStack^ [yyStackPtr].Scan := $.Attribute;
  143. $@            yyTerminal := $.GetToken ();
  144.            yyIsRepairing := FALSE;
  145. $X           yyState := yyFinalToProd [yyState];
  146.         END;
  147.  
  148.         LOOP                    (* reduce *)
  149. $R    (* Code for Reductions is inserted here *)
  150.            (* SPEC State := Next (Top (), Nonterminal); nonterminal transition *)
  151.            yyNCombPtr := yyNCombTypePtr (LONGCARD (yyNBasePtr [yyStateStack^ [yyStackPtr]])
  152.                 + yyNonterminal * SYSTEM.TSIZE (yyNCombType));
  153.            yyState := yyNCombPtr^;
  154.            INC (yyStackPtr);
  155.            yyAttributeStack^ [yyStackPtr] := yySynAttribute;
  156.            IF yyState < yyFirstFinalState THEN EXIT END; (* read nonterminal ? *)
  157. $X           yyState := yyFinalToProd [yyState];
  158.         END;
  159.  
  160.      ELSE                        (* read *)
  161.         INC (yyStackPtr);
  162. $@         yyAttributeStack^ [yyStackPtr].Scan := $.Attribute;
  163. $@         yyTerminal := $.GetToken ();
  164.         yyIsRepairing := FALSE;
  165.      END;
  166.       END;
  167. $@    END @;
  168.  
  169. PROCEDURE ErrorRecovery (
  170.       VAR Terminal    : yySymbolRange    ;
  171.       StateStack    : yyStackType    ;
  172.       StackSize    : LONGINT    ;
  173.       StackPtr    : LONGINT    );
  174.    VAR
  175.       TokensSkipped    : BOOLEAN;
  176.       ContinueSet    : Sets.tSet;
  177.       RestartSet    : Sets.tSet;
  178.       Token        : yySymbolRange;
  179.       TokenArray    : ARRAY [0..127] OF CHAR;
  180.       TokenString    : Strings.tString;
  181.       ContinueString    : Strings.tString;
  182.    BEGIN
  183.    (* 1. report the error *)
  184. $@       Errors.ErrorMessage (Errors.SyntaxError, Errors.Error, $.Attribute.Position);
  185.  
  186.    (* 2. report the set of expected terminal symbols *)
  187.       Sets.MakeSet (ContinueSet, yyLastTerminal);
  188.       ComputeContinuation (StateStack, StackSize, StackPtr, ContinueSet);
  189.       Strings.AssignEmpty (ContinueString);
  190.       FOR Token := Sets.Minimum (ContinueSet) TO Sets.Maximum (ContinueSet) DO
  191.      IF Sets.IsElement (Token, ContinueSet) THEN
  192.         TokenName (Token, TokenArray);
  193.         Strings.ArrayToString (TokenArray, TokenString);
  194.         IF (Strings.Length (ContinueString) + Strings.Length (TokenString) + 1 <= Strings.cMaxStrLength) THEN
  195.            Strings.Concatenate (ContinueString, TokenString);
  196.            Strings.Append (ContinueString, ' ');
  197.         END;
  198.      END;
  199.       END;
  200.       Errors.ErrorMessageI (Errors.ExpectedTokens, Errors.Information,
  201. $@      $.Attribute.Position, Errors.String, SYSTEM.ADR (ContinueString));
  202.       Sets.ReleaseSet (ContinueSet);
  203.  
  204.    (* 3. compute the set of terminal symbols for restart of the parse *)
  205.       Sets.MakeSet (RestartSet, yyLastTerminal);
  206.       ComputeRestartPoints (StateStack, StackSize, StackPtr, RestartSet);
  207.  
  208.    (* 4. skip terminal symbols until a restart point is reached *)
  209.       TokensSkipped := FALSE;
  210.       WHILE NOT Sets.IsElement (Terminal, RestartSet) DO
  211. $@      Terminal := $.GetToken ();
  212.      TokensSkipped := TRUE;
  213.       END;
  214.       Sets.ReleaseSet (RestartSet);
  215.  
  216.    (* 5. report the restart point *)
  217.       IF TokensSkipped THEN
  218. $@      Errors.ErrorMessage (Errors.RestartPoint, Errors.Information, $.Attribute.Position);
  219.       END;
  220.    END ErrorRecovery;
  221.  
  222. (*
  223.    compute the set of terminal symbols that can be accepted (read)
  224.    in a given stack configuration (eventually after reduce actions)
  225. *)
  226.  
  227. PROCEDURE ComputeContinuation (
  228.       Stack        : yyStackType    ;
  229.       StackSize    : LONGINT    ;
  230.       StackPtr    : LONGINT    ;
  231.       VAR ContinueSet    : Sets.tSet    );
  232.    VAR Terminal        : yySymbolRange;
  233.    BEGIN
  234.       Sets.AssignEmpty (ContinueSet);
  235.       FOR Terminal := yyFirstTerminal TO yyLastTerminal DO
  236.      IF IsContinuation (Terminal, Stack, StackSize, StackPtr) THEN
  237.         Sets.Include (ContinueSet, Terminal);
  238.      END;
  239.       END;
  240.    END ComputeContinuation;
  241.  
  242. (*
  243.    check whether a given terminal symbol can be accepted (read)
  244.    in a certain stack configuration (eventually after reduce actions)
  245. *)
  246.  
  247. PROCEDURE IsContinuation (
  248.       Terminal        : yySymbolRange    ;
  249.       ParseStack    : yyStackType    ;
  250.       StackSize        : LONGINT    ;
  251.       StackPtr        : LONGINT    ): BOOLEAN;
  252.    VAR
  253.       State        : LONGINT;
  254.       Nonterminal    : yySymbolRange;
  255.       Stack        : yyStackType;
  256.    BEGIN
  257.       DynArray.MakeArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  258.       FOR State := 0 TO StackPtr DO
  259.      Stack^ [State] := ParseStack^ [State];
  260.       END;
  261.       State := Stack^ [StackPtr];
  262.       LOOP
  263.      Stack^ [StackPtr] := State;
  264.      State := Next (State, Terminal);
  265.      IF State = yyNoState THEN
  266.         DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  267.         RETURN FALSE;
  268.      END;
  269.      IF State <= yyLastReadTermState THEN        (* read or read terminal reduce ? *)
  270.         DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  271.         RETURN TRUE;
  272.      END;
  273.  
  274.      LOOP                        (* reduce *)
  275.         IF State =    yyStopState THEN
  276.            DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  277.            RETURN TRUE;
  278.         ELSE 
  279.            DEC (StackPtr, yyLength [State]);
  280.            Nonterminal := yyLeftHandSide [State];
  281.         END;
  282.  
  283.         State := Next (Stack^ [StackPtr], Nonterminal);
  284.         IF StackPtr >= StackSize THEN
  285.            DynArray.ExtendArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  286.         END;
  287.         INC (StackPtr);
  288.         IF State < yyFirstFinalState THEN EXIT; END; (* read nonterminal ? *)
  289.         State := yyFinalToProd [State];        (* read nonterminal reduce *)
  290.      END;
  291.       END;
  292.    END IsContinuation;
  293.  
  294. (*
  295.    compute a set of terminal symbols that can be used to restart
  296.    parsing in a given stack configuration. we simulate parsing until
  297.    end of file using a suffix program synthesized by the function
  298.    Continuation. All symbols acceptable in the states reached during
  299.    the simulation can be used to restart parsing.
  300. *)
  301.  
  302. PROCEDURE ComputeRestartPoints (
  303.       ParseStack    : yyStackType    ;
  304.       StackSize    : LONGINT    ;
  305.       StackPtr    : LONGINT    ;
  306.       VAR RestartSet    : Sets.tSet    );
  307.    VAR
  308.       Stack        : yyStackType;
  309.       State        : LONGINT;
  310.       Nonterminal    : yySymbolRange;
  311.       ContinueSet    : Sets.tSet;
  312.    BEGIN
  313.       DynArray.MakeArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  314.       FOR State := 0 TO StackPtr DO
  315.      Stack^ [State] := ParseStack^ [State];
  316.       END;
  317.       Sets.MakeSet (ContinueSet, yyLastTerminal);
  318.       Sets.AssignEmpty (RestartSet);
  319.       State := Stack^ [StackPtr];
  320.  
  321.       LOOP
  322.      IF StackPtr >= StackSize THEN
  323.         DynArray.ExtendArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  324.      END;
  325.      Stack^ [StackPtr] := State;
  326.      ComputeContinuation (Stack, StackSize, StackPtr, ContinueSet);
  327.      Sets.Union (RestartSet, ContinueSet);
  328.      State := Next (State, yyContinuation [State]);
  329.  
  330.      IF State >= yyFirstFinalState THEN        (* final state ? *)
  331.         IF State <= yyLastReadTermState THEN    (* read terminal reduce ? *)
  332.            INC (StackPtr);
  333.            State := yyFinalToProd [State];
  334.         END;
  335.  
  336.         LOOP                    (* reduce *)
  337.            IF State = yyStopState THEN
  338.           DynArray.ReleaseArray (Stack, StackSize, SYSTEM.TSIZE (yyStateRange));
  339.           Sets.ReleaseSet (ContinueSet);
  340.           RETURN;
  341.            ELSE 
  342.           DEC (StackPtr, yyLength [State]);
  343.           Nonterminal := yyLeftHandSide [State];
  344.            END;
  345.  
  346.            State := Next (Stack^ [StackPtr], Nonterminal);
  347.            INC (StackPtr);
  348.            IF State < yyFirstFinalState THEN EXIT; END; (* read nonterminal ? *)
  349.            State := yyFinalToProd [State];        (* read nonterminal reduce *)
  350.         END;
  351.      ELSE                        (* read *)
  352.         INC (StackPtr);
  353.      END;
  354.       END;
  355.    END ComputeRestartPoints;
  356.  
  357. (* access the parse table:   Next : State x Symbol -> State *)
  358.  
  359. PROCEDURE Next (State: yyStateRange; Symbol: yySymbolRange): yyStateRange;
  360.    VAR
  361.       TCombPtr        : yyTCombTypePtr;
  362.       NCombPtr        : yyNCombTypePtr;
  363.    BEGIN
  364.       IF Symbol <= yyLastTerminal THEN
  365.      LOOP
  366.         TCombPtr := yyTCombTypePtr (LONGCARD (yyTBasePtr [State]) 
  367.                + Symbol * SYSTEM.TSIZE (yyTCombType));
  368.         IF TCombPtr^.Check # State THEN
  369.            State := yyDefault [State];
  370.            IF State = yyNoState THEN RETURN yyNoState; END;
  371.         ELSE
  372.            RETURN TCombPtr^.Next;
  373.         END;
  374.      END;
  375.       ELSE
  376.     NCombPtr := yyNCombTypePtr (LONGCARD (yyNBasePtr [State]) 
  377.             + Symbol * SYSTEM.TSIZE (yyNCombType));
  378.     RETURN NCombPtr^;
  379.       END;
  380.    END Next;
  381.  
  382. PROCEDURE yyGetTables;
  383.    VAR
  384.       BlockSize, j, n    : CARDINAL;
  385.       State    : yyStateRange;
  386.       TBase    : ARRAY [0 .. yyLastReadState] OF yyTCombRange;
  387.       NBase    : ARRAY [0 .. yyLastReadState] OF yyNCombRange;
  388.    BEGIN
  389.       BlockSize    := 64000 DIV SYSTEM.TSIZE (yyTCombType);
  390.       yyTableFile := System.OpenInput (ParsTabName);
  391.       yyErrorCheck (Errors.OpenParseTable, yyTableFile);
  392.       IF 
  393.      (yyGetTable (SYSTEM.ADR (TBase            )) DIV SYSTEM.TSIZE (yyTCombRange ) - 1
  394.         # yyLastReadState) OR
  395.      (yyGetTable (SYSTEM.ADR (NBase            )) DIV SYSTEM.TSIZE (yyNCombRange ) - 1
  396.         # yyLastReadState) OR
  397.      (yyGetTable (SYSTEM.ADR (yyDefault     )) DIV SYSTEM.TSIZE (yyReadRange  ) - 1
  398.         # yyLastReadState) OR
  399.      (yyGetTable (SYSTEM.ADR (yyNComb       )) DIV SYSTEM.TSIZE (yyNCombType  )
  400.         # yyNTableMax - yyLastTerminal) OR
  401.      (yyGetTable (SYSTEM.ADR (yyLength      )) DIV SYSTEM.TSIZE (yyTableElmt  ) - 1
  402.         # yyLastReduceState - yyFirstReduceState) OR
  403.      (yyGetTable (SYSTEM.ADR (yyLeftHandSide)) DIV SYSTEM.TSIZE (yySymbolRange) - 1
  404.         # yyLastReduceState - yyFirstReduceState) OR
  405.      (yyGetTable (SYSTEM.ADR (yyContinuation)) DIV SYSTEM.TSIZE (yySymbolRange) - 1
  406.         # yyLastReadState) OR
  407.      (yyGetTable (SYSTEM.ADR (yyFinalToProd )) DIV SYSTEM.TSIZE (yyReduceRange) - 1
  408.         # yyLastReadNontermState - yyFirstReadTermState)
  409.       THEN
  410.      Errors.ErrorMessage (Errors.WrongParseTable, Errors.Fatal, Positions.NoPosition);
  411.       END;
  412.       n := 0;
  413.       j := 0;
  414.       WHILE j <= yyTableMax DO
  415.      INC (n, yyGetTable (SYSTEM.ADR (yyTComb [j])) DIV SYSTEM.TSIZE (yyTCombType));
  416.          INC (j, BlockSize);
  417.       END;
  418.       IF n # yyTableMax + 1 THEN 
  419.      Errors.ErrorMessage (Errors.WrongParseTable, Errors.Fatal, Positions.NoPosition);
  420.       END;
  421.       System.Close (yyTableFile);
  422.  
  423.       FOR State := 1 TO yyLastReadState DO
  424.      yyTBasePtr [State] := SYSTEM.ADR (yyTComb [TBase [State]]);
  425.       END;
  426.       FOR State := 1 TO yyLastReadState DO
  427.      yyNBasePtr [State] := SYSTEM.ADR (yyNComb [NBase [State]]);
  428.       END;
  429.    END yyGetTables;
  430.  
  431. PROCEDURE yyGetTable (Address: SYSTEM.ADDRESS): CARDINAL;
  432.    VAR
  433.       N        : INTEGER;
  434.       Length    : yyTableElmt;
  435.    BEGIN
  436.       N := System.Read (yyTableFile, SYSTEM.ADR (Length), SYSTEM.TSIZE (yyTableElmt));
  437.       yyErrorCheck (Errors.ReadParseTable, N);
  438.       N := System.Read (yyTableFile, Address, Length);
  439.       yyErrorCheck (Errors.ReadParseTable, N);
  440.       RETURN Length;
  441.    END yyGetTable;
  442.  
  443. PROCEDURE yyErrorCheck (ErrorCode: INTEGER; Info: INTEGER);
  444.    VAR ErrNo: INTEGER;
  445.    BEGIN
  446.      IF Info < 0 THEN
  447.     ErrNo := System.ErrNum ();
  448.     Errors.ErrorMessageI (ErrorCode, Errors.Fatal, Positions.NoPosition,
  449.        Errors.Integer, SYSTEM.ADR (ErrNo));
  450.      END;
  451.    END yyErrorCheck;
  452.  
  453. $@ PROCEDURE Begin@;
  454.    BEGIN
  455. $B    (* BEGIN section is inserted here *)
  456.       IF NOT yyIsInitialized THEN
  457.      yyIsInitialized := TRUE;
  458.      yyGetTables;
  459.       END;
  460. $@    END Begin@;
  461.  
  462. $@ PROCEDURE Close@;
  463.    BEGIN
  464. $C    (* CLOSE section is inserted here *)
  465. $@    END Close@;
  466.  
  467. BEGIN
  468.     yyIsInitialized := FALSE;
  469. $@     ParsTabName := '@.Tab';
  470. $@ END @.
  471.